use eframe::egui;
use std::sync::{Arc, Mutex};

use super::manager::ShellManager;

/// 终端界面组件，提供shell交互界面
pub struct TerminalWidget {
    shell_manager: Arc<Mutex<ShellManager>>,
    terminal_text: String,
    current_input: String,
    scroll_to_bottom: bool,
}

impl TerminalWidget {
    /// 创建新的终端组件
    pub fn new() -> Self {
        let shell_manager = Arc::new(Mutex::new(ShellManager::new()));

        // 启动shell进程
        {
            let mut manager = shell_manager.lock().unwrap();
            if let Err(e) = manager.start() {
                eprintln!("Failed to start shell: {}", e);
            }
        }

        Self {
            shell_manager,
            terminal_text: String::new(),
            current_input: String::new(),
            scroll_to_bottom: true,
        }
    }

    /// 显示终端界面
    pub fn show(&mut self, ui: &mut egui::Ui) {
        // 更新输出内容
        self.update_output();

        // 创建滚动区域
        let scroll_area = egui::ScrollArea::vertical()
            .auto_shrink([false, false])
            .stick_to_bottom(self.scroll_to_bottom);

        scroll_area.show(ui, |ui| {
            // 显示终端输出
            ui.add(
                egui::TextEdit::multiline(&mut self.terminal_text)
                    .id_source("terminal_output")
                    .font(egui::TextStyle::Monospace)
                    .interactive(false)
                    .desired_width(ui.available_width()),
            );
        });

        // 重置滚动标志
        self.scroll_to_bottom = false;

        // 添加分隔线
        ui.separator();

        // 输入区域
        ui.horizontal(|ui| {
            // 命令提示符
            ui.label(
                egui::RichText::new("$")
                    .color(egui::Color32::GREEN)
                    .monospace(),
            );

            // 输入框
            let input_response = ui.add(
                egui::TextEdit::singleline(&mut self.current_input)
                    .id_source("terminal_input")
                    .font(egui::TextStyle::Monospace)
                    .desired_width(ui.available_width() - 30.0),
            );

            // 处理回车键
            if input_response.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter)) {
                self.execute_command();
            }

            // 直接在输入框内处理回车键
            if input_response.has_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter)) {
                self.execute_command();
            }

            // 输入框获取焦点
            input_response.request_focus();
        });

        // 状态栏
        ui.horizontal(|ui| {
            {
                let manager = self.shell_manager.lock().unwrap();
                let status_text = if manager.is_running() {
                    egui::RichText::new("● Running").color(egui::Color32::GREEN)
                } else {
                    egui::RichText::new("● Stopped").color(egui::Color32::RED)
                };
                ui.label(status_text);
            }

            // 清空按钮
            if ui.button("Clear").clicked() {
                self.clear_terminal();
            }
        });
    }

    /// 执行当前输入的命令
    fn execute_command(&mut self) {
        if self.current_input.trim().is_empty() {
            return;
        }

        let command = self.current_input.clone();

        // 添加到终端显示
        self.terminal_text.push_str(&format!("$ {}\n", command));

        // 发送到shell
        {
            let mut manager = self.shell_manager.lock().unwrap();
            if let Err(e) = manager.send_command(&command) {
                self.terminal_text.push_str(&format!("Error: {}\n", e));
            }
        }

        // 清空输入
        self.current_input.clear();
        self.scroll_to_bottom = true;
    }

    /// 更新输出内容
    fn update_output(&mut self) {
        let manager = self.shell_manager.lock().unwrap();
        let new_output = manager.get_output();

        if !new_output.is_empty() {
            self.terminal_text.push_str(&new_output);
            self.scroll_to_bottom = true;

            // 清空shell管理器的输出缓冲区，避免重复显示
            drop(manager); // 释放锁
            let mut manager = self.shell_manager.lock().unwrap();
            manager.clear_output();
        }
    }

    /// 清空终端显示
    fn clear_terminal(&mut self) {
        self.terminal_text.clear();
    }

    /// 获取shell管理器引用（用于外部控制）
    pub fn get_shell_manager(&self) -> Arc<Mutex<ShellManager>> {
        Arc::clone(&self.shell_manager)
    }

    /// 手动执行命令（用于外部调用，比如AI建议）
    pub fn execute_external_command(&mut self, command: &str) {
        self.current_input = command.to_string();
        self.execute_command();
    }
}

impl Default for TerminalWidget {
    fn default() -> Self {
        Self::new()
    }
}
